// pages/class_leave/class_leave.js
var mm = require("/../js/thenBy.js");   //调用第三方库
Page({

  /**
   * 页面的初始数据
   */
  data: {
    if_show: 0,
    listArr: [],        //循环中班级请假信息界面所需数据暂时存放变量
    Arr: [],            //班级请假信息界面所需数据
    h: [],
    input_data: '',      //老师名字
    things_school_id: 0,
    a: 0,               //第二次分组时，循环所需的变量
    c: 0,               //向listArr数组插入信息时，循环所需的变量
    d: 0,               //向listArr数组插入信息的循环中，maybe的下标
    sum: 0,             //listArr数组的对象个数
    list: [],           //传递两次分组后的数据
    con: 0,             //0常量
    show: false,        //搜索不到时显示
    show_text: '没有相关数据！',       //搜索不到时显示文字
    Akey: '',           //搜索框输入文字暂存变量
    i: 0                //搜索所需循环变量
  },
  GroupBy(array, fn){      //groupby分组函数
    const groups ={};
    array.forEach(
      function(item){
        const group = JSON.stringify(fn(item));
        groups[group] = groups[group] || [];
        groups[group].push(item);
      }
    );
    return Object.keys(groups).map(
      function(group){
        return groups[group];
      }
    );
  },
  /*
  实现思路：
  1、函数groupBy有两个形参，一为对象数组，二为匿名函数（该函数功能：返回对象的某个指定属性的属性值并存放在数组中）；
  2、groupBy函数内，先创建一个空对象；
  3、然后forEach遍历对象数组，遍历时要执行的函数中只有一个形参item（数组中的每个元素）；
  4、const group = JSON.stringify( fn(item) )，相当于先获取到对象数组中的某属性对应的属性值并放入数组中，然后再将属性值转换为json字符串；
  5、groups[group] = groups[group] || []，在js中对象也是关联数组，因此这里相当于做了两件事，一是把group作为groups的key，二是将对应的value初始化，第一次执行为空数组，循环执行时找到相同的属性时保持不变；
  6、groups[group].push( item )，这句相当于把对象数组中每个对象压入数组中作为value；
  7、最后，Object.keys(groups)是取出groups对象中的所有key，然后遍历一个个key组成的新数组，返回分好了组的二维数组
  */

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    this.setData({   //获取上个页面传过来的input_data
      input_data: options.input_data,
      things_school_id: options.things_school_id
    })
    this.getLeave()
  },

  getLeave(){    //获取请假信息
    this.get()
  },

  get(){
    var that = this
    return new Promise(function (resolve, reject) {
      wx.cloud.callFunction({      //调用云函数
        name: 'find',
        data: {
          name_collection:"things_table",//集合名称
          condition:{//条件
            class_teacher: that.data.input_data,
            college_examine: true,
            teacher_examine: true,
            things_school_id: that.data.things_school_id
          },
          data:{
          }
        },
        success(res){
          //console.log("success",res);     //打印成功回调
          that.setData({
            h: res.result.data
          })
          var m = 0;
          that.data.h.forEach(item => {item.input_classA = ''});
          that.data.h.forEach(item => {item.input_classB = ''});
          that.data.h.forEach(item => {item.input_classC = ''});
          that.data.h.forEach(item => {item.input_classD = ''});
          while(m < that.data.h.length){
            var input_classA = 'h['+m+'].input_classA';
            var input_classB = 'h['+m+'].input_classB';
            var input_classC = 'h['+m+'].input_classC';
            var input_classD = 'h['+m+'].input_classD';
            var A = ((that.data.h[m]).input_class).split(" ");
            that.setData({
              [input_classA]: A[0],
              [input_classB]: A[1],
              [input_classC]: A[2],
              [input_classD]: A[1] + A[2]
            })
            m = m + 1;
          }
          var z = that.data.h;
          z = z.sort(mm.firstBy(function (a, b){     //年级排序  mm.firstBy().thenBy().thenBy() 调用了第三方js库：thenby.js库
            var value1 = a.input_classA;                          //调用库的语句在第二行
            var value2 = b.input_classA;
            return value1 - value2;
          }).thenBy(function (x, y){     //班级排序
            var value3 = x.input_classB;
            var value4 = y.input_classB;
            return value3.localeCompare(value4);
          }).thenBy(function (m, n){     //班级排序
            var value5 = m.input_classC.substr(0,1);
            var value6 = n.input_classC.substr(0,1);
            return value5 - value6;
          }));
          var arr = z.filter((p) => {    //筛选符合时间的数据
            var date = Date.parse(new Date());
            //date = date / 1000;
            var tarvel_time = new Date(p.tarvel_time).getTime();
            var return_time = new Date(p.return_time).getTime();
            return tarvel_time <= date && return_time >= date; 
          });
          //results是根据input_classA分组后的数组
          const results = that.GroupBy(arr, function(item){return [item.input_classA];});
          //console.log(results)
          var b = []
          while(that.data.a < results.length){
            //maybe是在results的基础上再根据stu_class分组
            const maybe = that.GroupBy(results[that.data.a], function(item){return [item.input_classD];});
            //console.log(maybe)
            b[that.data.a] = maybe     //将分组后的数据放入b数组
            var aaa = that.data.sum
            that.setData({
              sum: aaa + maybe.length   //更新listArr数组的最大长度，方便向listArr数组插入时使用循环
            })
            while(that.data.c < that.data.sum){            //使用循环将input_classA，input_classD，length信息插入到listArr数组
              that.data.listArr[that.data.c] = {
                input_classA: (maybe[that.data.d][0]).input_classA,   
                input_classD: (maybe[that.data.d][0]).input_classD,
                length: (maybe[that.data.d]).length,
                list_index1: that.data.a,
                list_index2: that.data.con
              }
              that.setData({
                c : that.data.c + 1,
                con : that.data.con + 1,
                d : that.data.d + 1
              })
            }
            that.setData({
              a : that.data.a + 1,
              d : 0,
              con : 0,
            })
          }
          that.setData({
            Arr: that.data.listArr,
            list: b,
            a: 0,
            c: 0,
            sum: 0
          })
          wx.setStorage({     //数据缓存
            key:"listArr",
            data:that.data.listArr
          })
          try {
            wx.setStorageSync('listArr',that.data.listArr)
          } catch (e) { }
          wx.setStorage({     //数据缓存
            key:"list_group",
            data:that.data.list
          })
          try {
            wx.setStorageSync('list_group',that.data.list)
          } catch (e) { }
          resolve([that.data.list,that.data.Arr])
        },//成功的回调
        fail(res){
          console.log("fail",res)
        }
      })
    })
  },

  //键盘输入时实时调用搜索方法
  input(e){
    //console.log(e.detail)
    this.search(e.detail.value)
  },

  search(key){         //根据输入框搜索数据
    this.setData({
      Akey: key,
      show: false
    })
    var that = this;
    wx.getStorage({          //获取缓存数据
      key: 'listArr',
      success (res) {
        //console.log(res.data)
        if (that.data.Akey == ''){            //搜索为空，显示所有
          that.setData({
            Arr: res.data
          })
        }else{ 
          var arr = [];   //暂时数组，存放数据
          var list = that.data.Akey.split(" ")  //将搜索框中输入内容以空格为分隔符切割
          while(that.data.i < res.data.length){
            if((res.data[that.data.i].input_classA).indexOf(list[0]) >= 0){
              if(((list[1] != undefined) && (res.data[that.data.i].input_classD).indexOf(list[1]) >= 0) || (list[1] == undefined)){
                arr.push(res.data[that.data.i])
                that.setData({
                  i: that.data.i + 1
                })
              }else{
                that.setData({
                  i: that.data.i + 1
                })
              }
            }else if((res.data[that.data.i].input_classD).indexOf(list[0]) >= 0){
              arr.push(res.data[that.data.i])
              that.setData({
                i: that.data.i + 1
              })
            }else{
              that.setData({
                i: that.data.i + 1
              })
            }
          }
          //console.log(arr)
          that.setData({
            i: 0
          })
          if (arr.length == 0) {
            that.setData({
              Arr: [],
              show: true
            })
          } else {
            that.setData({
              Arr: arr
            })
          }
        }
      }
    })
    try {
      var value = wx.getStorageSync('listArr')
      if (value) {
        // Do something with return value
      }
    } catch (e) {
      // Do something when catch error
    }
  },  

  toClass_detail(event){  //跳转class_detail
    //获取点击跳转对应的下标
    let index = event.currentTarget.dataset.index;
    wx.navigateTo({
      url: '/pages/teacher_class_detail/teacher_class_detail?index='+index+'&list='+JSON.stringify(this.data.list[(this.data.Arr[index]).list_index1][(this.data.Arr[index]).list_index2])+'&input_data='+this.data.input_data
    })
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    if(this.data.if_show == 1){
      this.getLeave()
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {
    this.setData({
      if_show: 1
    })
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: function () {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function () {

  }
})